#include <string>

using namespace std;


#define FINST_NUM 110
#define AVXINST_NUM 246



namespace InstType
{
	enum FloatInst
	{		
		FBST,		
		FCOM,
		
		F2XM1,
		FABS,
		
		FADD,
		FADDP,
		FIADD,
		
		FBLD,
		FBSTP,
		FCHS,
		
		FCLEX,
		FNCLEX,
		
		FCMOVcc,
		
		FCOMP,
		FCOMPP,
		FCOMI,
		FCOMIP,
		FUCOMI,
		CUCOMIP,
		
		FCOS,
		FDECSTP,
		FFREE,
		
		FDIV,
		FDIVP,
		FIDIV,
		FDIVR,
		FDIVRP,
		FIDIVR,
		
		FICOM,
		FICOMP,
		
		FILD,
		FINCSTP,
		FINIT,
		FNINIT,
		FIST,
		FISTP,
		FISTTP,
		
		FLD,
		FLD1,
		FLDL2T,
		FLDL2E,
		FLDPI,
		FLDLG2,
		FLDLN2,
		FLDZ,
		
		FLDCW,
		FLDENV,
		
		FMUL,
		FMULP,
		FIMUL,
		FNOP,
		FPATAN,
		FPREM,
		FPREM1,
		FPTAN,
		FRNDINT,
		FRSTOR,
		FSAVE,
		FNSAVE,
		FSCALE,
		FSIN,
		FSINCOS,
		FSQRT,
		FST,
		FSTP,
		FSTCW, 	
		FNSTCW,
		FSTENV, 
		FNSTENV,
		FSTSW,  
		FNSTSW,
		FSUB, 
		FSUBP, 
		FISUB,
		FSUBR, 
		FSUBRP, 
		FISUBR,
		FTST,
		FUCOM, 
		FUCOMP, 
		FUCOMPP,
		FXAM,
		FXCH,
		FXRSTOR,
		FXSAVE,
		FXTRACT,
		FYL2X,
		FYL2XP1		
	};
}

struct StFloat
{
	InstType::FloatInst m_nID;
	string m_szName;
};

const StFloat g_FloatInstArr[FINST_NUM] =
{
	{InstType::FBST, "FBST"},
{InstType::FCOM, "FCOM"},
{InstType::F2XM1, "F2XM1"},
{InstType::FABS, "FABS"},
{InstType::FADD, "FADD"},
{InstType::FADDP, "FADDP"},
{InstType::FIADD, "FIADD"},
{InstType::FBLD, "FBLD"},
{InstType::FBSTP, "FBSTP"},
{InstType::FCHS, "FCHS"},
{InstType::FCLEX, "FCLEX"},
{InstType::FNCLEX, "FNCLEX"},
{InstType::FCMOVcc, "FCMOVcc"},
{InstType::FCOMP, "FCOMP"},
{InstType::FCOMPP, "FCOMPP"},
{InstType::FCOMI, "FCOMI"},
{InstType::FCOMIP, "FCOMIP"},
{InstType::FUCOMI, "FUCOMI"},
{InstType::CUCOMIP, "CUCOMIP"},
{InstType::FCOS, "FCOS"},
{InstType::FDECSTP, "FDECSTP"},
{InstType::FFREE, "FFREE"},
{InstType::FDIV, "FDIV"},
{InstType::FDIVP, "FDIVP"},
{InstType::FIDIV, "FIDIV"},
{InstType::FDIVR, "FDIVR"},
{InstType::FDIVRP, "FDIVRP"},
{InstType::FIDIVR, "FIDIVR"},
{InstType::FICOM, "FICOM"},
{InstType::FICOMP, "FICOMP"},
{InstType::FILD, "FILD"},
{InstType::FINCSTP, "FINCSTP"},
{InstType::FINIT, "FINIT"},
{InstType::FNINIT, "FNINIT"},
{InstType::FIST, "FIST"},
{InstType::FISTP, "FISTP"},
{InstType::FISTTP, "FISTTP"},
{InstType::FLD, "FLD"},
{InstType::FLD1, "FLD1"},
{InstType::FLDL2T, "FLDL2T"},
{InstType::FLDL2E, "FLDL2E"},
{InstType::FLDPI, "FLDPI"},
{InstType::FLDLG2, "FLDLG2"},
{InstType::FLDLN2, "FLDLN2"},
{InstType::FLDZ, "FLDZ"},
{InstType::FLDCW, "FLDCW"},
{InstType::FLDENV, "FLDENV"},
{InstType::FMUL, "FMUL"},
{InstType::FMULP, "FMULP"},
{InstType::FIMUL, "FIMUL"},
{InstType::FNOP, "FNOP"},
{InstType::FPATAN, "FPATAN"},
{InstType::FPREM, "FPREM"},
{InstType::FPREM1, "FPREM1"},
{InstType::FPTAN, "FPTAN"},
{InstType::FRNDINT, "FRNDINT"},
{InstType::FRSTOR, "FRSTOR"},
{InstType::FSAVE, "FSAVE"},
{InstType::FNSAVE, "FNSAVE"},
{InstType::FSCALE, "FSCALE"},
{InstType::FSIN, "FSIN"},
{InstType::FSINCOS, "FSINCOS"},
{InstType::FSQRT, "FSQRT"},
{InstType::FST, "FST"},
{InstType::FSTP, "FSTP"},
{InstType::FSTCW, "FSTCW"},
{InstType::FNSTCW, "FNSTCW"},
{InstType::FSTENV, "FSTENV"},
{InstType::FNSTENV, "FNSTENV"},
{InstType::FSTSW, "FSTSW"},
{InstType::FNSTSW, "FNSTSW"},
{InstType::FSUB, "FSUB"},
{InstType::FSUBP, "FSUBP"},
{InstType::FISUB, "FISUB"},
{InstType::FSUBR, "FSUBR"},
{InstType::FSUBRP, "FSUBRP"},
{InstType::FISUBR, "FISUBR"},
{InstType::FTST, "FTST"},
{InstType::FUCOM, "FUCOM"},
{InstType::FUCOMP, "FUCOMP"},
{InstType::FUCOMPP, "FUCOMPP"},
{InstType::FXAM, "FXAM"},
{InstType::FXCH, "FXCH"},
{InstType::FXRSTOR, "FXRSTOR"},
{InstType::FXSAVE, "FXSAVE"},
{InstType::FXTRACT, "FXTRACT"},
{InstType::FYL2X, "FYL2X"},
{InstType::FYL2XP1, "FYL2XP1"}
};

namespace InstType
{
	enum AvxInst
	{
		ADDPD,
		ADDPS,
		ADDSD,
		ADDSS,		
		VADDPD,
		VADDPS,
		VADDSD,
		VADDSS,
		
		ADDSUBPD,
		ADDSUBPS,
		ANDPD,
		ANDPS,
		ANDNPD,
		ANDNPS,
		VADDSUBPD,
		VADDSUBPS,
		VANDPD,
		VANDPS,
		VANDNPD,
		VANDNPS,
		
		BLENDPD,
		BLENDPS,
		BLENDVPD,
		BLENDVPS,
		VBLENDPD,
		VBLENDPS,
		VBLENDVPD,
		VBLENDVPS,
		
		CMPPD,
		CMPPS,
		CMPSD,
		CMPSS,
		COMISD,
		COMISS,
		VCMPPD,
		VCMPPS,
		VCMPSD,
		VCMPSS,
		VCOMISD,
		VCOMISS,
		
		CVTDQ2PD,
		CVTPD2DQ,
		CVTPD2PI,
		CVTPD2PS,
		CVTPI2PD,
		CVTPI2PS,
		CVTPS2DQ,
		CVTPS2PD,
		CVTPS2PI,
		CVTSD2SI,
		CVTSD2SS,
		CVTSI2SD,
		CVTSI2SS,
		CVTSS2SD,
		CVTSS2SI,
		CVTTPD2DQ,
		CVTTPD2PI,
		CVTTPS2DQ,
		CVTTPS2PI,
		CVTTSD2SI,
		CVTTSS2SI,		
		VCVTDQ2PD,
		VCVTPD2DQ,
		VCVTPD2PI,
		VCVTPD2PS,
		VCVTPI2PD,
		VCVTPI2PS,
		VCVTPS2DQ,
		VCVTPS2PD,
		VCVTPS2PI,
		VCVTSD2SI,
		VCVTSD2SS,
		VCVTSI2SD,
		VCVTSI2SS,
		VCVTSS2SD,
		VCVTSS2SI,
		VCVTTPD2DQ,
		VCVTTPD2PI,
		VCVTTPS2DQ,
		VCVTTPS2PI,
		VCVTTSD2SI,
		VCVTTSS2SI,
		
		DIVPD,
		DIVPS,
		DIVSD,
		DIVSS,
		DPPD,
		DPPS,
		EXTRACTPS,
		VDIVPD,
		VDIVPS,
		VDIVSD,
		VDIVSS,
		VDPPD,
		VDPPS,
		VEXTRACTPS,
		
		
		HADDPD,
		HADDPS,
		HSUBPD,
		HSUBPS,
		VHADDPD,
		VHADDPS,
		VHSUBPD,
		VHSUBPS,
		
		MAXPD,
		MAXPS,
		MAXSD,
		MAXSS,
		MINPD,
		MINPS,
		MINSD,
		MINSS,
		VMAXPD,
		VMAXPS,
		VMAXSD,
		VMAXSS,
		VMINPD,
		VMINPS,
		VMINSD,
		VMINSS,
		
		MOVAPD,
		MOVAPS,
		MOVHLPS,
		MOVHPD,
		MOVHPS,
		MOVLHPS,
		MOVLPD,
		MOVLPS,
		MOVMSKPD,
		MOVMSKPS,
		MOVNTPD,
		MOVNTPS,
		MOVSD,
		MOVSHDUP,
		MOVSLDUP,
		MOVSS,
		MOVUPD,
		MOVUPS,
		MULPD,
		MULPS,
		MULSD,
		MULSS,
		VMOVAPD,
		VMOVAPS,
		VMOVHLPS,
		VMOVHPD,
		VMOVHPS,
		VMOVLHPS,
		VMOVLPD,
		VMOVLPS,
		VMOVMSKPD,
		VMOVMSKPS,
		VMOVNTPD,
		VMOVNTPS,
		VMOVSD,
		VMOVSHDUP,
		VMOVSLDUP,
		VMOVSS,
		VMOVUPD,
		VMOVUPS,
		VMULPD,
		VMULPS,
		VMULSD,
		VMULSS,
		
		ORPD,
		ORPS,
		RCPPS,
		RCPSS,
		ROUNDPD,
		ROUNDPS,
		ROUNDSD,
		ROUNDSS,
		RSQRTPS,
		RSQRTSS,
		SHUFPD,
		SHUFPS,
		SQRTPD,
		SQRTPS,
		SQRTSD,
		SQRTSS,
		
		VORPD,
		VORPS,
		VRCPPS,
		VRCPSS,
		VROUNDPD,
		VROUNDPS,
		VROUNDSD,
		VROUNDSS,
		VRSQRTPS,
		VRSQRTSS,
		VSHUFPD,
		VSHUFPS,
		VSQRTPD,
		VSQRTPS,
		VSQRTSD,
		VSQRTSS,
		
		SUBPD,
		SUBPS,
		SUBSD,
		SUBSS,
		VSUBPD,
		VSUBPS,
		VSUBSD,
		VSUBSS,
		
		UCOMISD,
		UCOMISS,
		VUCOMISD,
		VUCOMISS,
		
		UNPCKHPD,
		UNPCKHPS,
		UNPCKLPD,
		UNPCKLPS,
		VUNPCKHPD,
		VUNPCKHPS,
		VUNPCKLPD,
		VUNPCKLPS,
		
		VCVTPH2PS,
		VCVTPS2PH,
		VEXTRACTF128,
		VINSERTF128,
		VPERMILPD,
		VPERMILPS,
		VPERM2F128,
		
		XORPD,
		XORPS,
		VXORPD,
		VXORPS		
	};
}

struct StAvx
{
	InstType::AvxInst m_nID;
	string m_szName;
};

const StAvx g_AvxInstArr[AVXINST_NUM] =
{
{InstType::ADDPD, "ADDPD"},
{InstType::ADDPS, "ADDPS"},
{InstType::ADDSD, "ADDSD"},
{InstType::ADDSS, "ADDSS"},
{InstType::VADDPD, "VADDPD"},
{InstType::VADDPS, "VADDPS"},
{InstType::VADDSD, "VADDSD"},
{InstType::VADDSS, "VADDSS"},
{InstType::ADDSUBPD, "ADDSUBPD"},
{InstType::ADDSUBPS, "ADDSUBPS"},
{InstType::ANDPD, "ANDPD"},
{InstType::ANDPS, "ANDPS"},
{InstType::ANDNPD, "ANDNPD"},
{InstType::ANDNPS, "ANDNPS"},
{InstType::VADDSUBPD, "VADDSUBPD"},
{InstType::VADDSUBPS, "VADDSUBPS"},
{InstType::VANDPD, "VANDPD"},
{InstType::VANDPS, "VANDPS"},
{InstType::VANDNPD, "VANDNPD"},
{InstType::VANDNPS, "VANDNPS"},
{InstType::BLENDPD, "BLENDPD"},
{InstType::BLENDPS, "BLENDPS"},
{InstType::BLENDVPD, "BLENDVPD"},
{InstType::BLENDVPS, "BLENDVPS"},
{InstType::VBLENDPD, "VBLENDPD"},
{InstType::VBLENDPS, "VBLENDPS"},
{InstType::VBLENDVPD, "VBLENDVPD"},
{InstType::VBLENDVPS, "VBLENDVPS"},
{InstType::CMPPD, "CMPPD"},
{InstType::CMPPS, "CMPPS"},
{InstType::CMPSD, "CMPSD"},
{InstType::CMPSS, "CMPSS"},
{InstType::COMISD, "COMISD"},
{InstType::COMISS, "COMISS"},
{InstType::VCMPPD, "VCMPPD"},
{InstType::VCMPPS, "VCMPPS"},
{InstType::VCMPSD, "VCMPSD"},
{InstType::VCMPSS, "VCMPSS"},
{InstType::VCOMISD, "VCOMISD"},
{InstType::VCOMISS, "VCOMISS"},
{InstType::CVTDQ2PD, "CVTDQ2PD"},
{InstType::CVTPD2DQ, "CVTPD2DQ"},
{InstType::CVTPD2PI, "CVTPD2PI"},
{InstType::CVTPD2PS, "CVTPD2PS"},
{InstType::CVTPI2PD, "CVTPI2PD"},
{InstType::CVTPI2PS, "CVTPI2PS"},
{InstType::CVTPS2DQ, "CVTPS2DQ"},
{InstType::CVTPS2PD, "CVTPS2PD"},
{InstType::CVTPS2PI, "CVTPS2PI"},
{InstType::CVTSD2SI, "CVTSD2SI"},
{InstType::CVTSD2SS, "CVTSD2SS"},
{InstType::CVTSI2SD, "CVTSI2SD"},
{InstType::CVTSI2SS, "CVTSI2SS"},
{InstType::CVTSS2SD, "CVTSS2SD"},
{InstType::CVTSS2SI, "CVTSS2SI"},
{InstType::CVTTPD2DQ, "CVTTPD2DQ"},
{InstType::CVTTPD2PI, "CVTTPD2PI"},
{InstType::CVTTPS2DQ, "CVTTPS2DQ"},
{InstType::CVTTPS2PI, "CVTTPS2PI"},
{InstType::CVTTSD2SI, "CVTTSD2SI"},
{InstType::CVTTSS2SI, "CVTTSS2SI"},
{InstType::VCVTDQ2PD, "VCVTDQ2PD"},
{InstType::VCVTPD2DQ, "VCVTPD2DQ"},
{InstType::VCVTPD2PI, "VCVTPD2PI"},
{InstType::VCVTPD2PS, "VCVTPD2PS"},
{InstType::VCVTPI2PD, "VCVTPI2PD"},
{InstType::VCVTPI2PS, "VCVTPI2PS"},
{InstType::VCVTPS2DQ, "VCVTPS2DQ"},
{InstType::VCVTPS2PD, "VCVTPS2PD"},
{InstType::VCVTPS2PI, "VCVTPS2PI"},
{InstType::VCVTSD2SI, "VCVTSD2SI"},
{InstType::VCVTSD2SS, "VCVTSD2SS"},
{InstType::VCVTSI2SD, "VCVTSI2SD"},
{InstType::VCVTSI2SS, "VCVTSI2SS"},
{InstType::VCVTSS2SD, "VCVTSS2SD"},
{InstType::VCVTSS2SI, "VCVTSS2SI"},
{InstType::VCVTTPD2DQ, "VCVTTPD2DQ"},
{InstType::VCVTTPD2PI, "VCVTTPD2PI"},
{InstType::VCVTTPS2DQ, "VCVTTPS2DQ"},
{InstType::VCVTTPS2PI, "VCVTTPS2PI"},
{InstType::VCVTTSD2SI, "VCVTTSD2SI"},
{InstType::VCVTTSS2SI, "VCVTTSS2SI"},
{InstType::DIVPD, "DIVPD"},
{InstType::DIVPS, "DIVPS"},
{InstType::DIVSD, "DIVSD"},
{InstType::DIVSS, "DIVSS"},
{InstType::DPPD, "DPPD"},
{InstType::DPPS, "DPPS"},
{InstType::EXTRACTPS, "EXTRACTPS"},
{InstType::VDIVPD, "VDIVPD"},
{InstType::VDIVPS, "VDIVPS"},
{InstType::VDIVSD, "VDIVSD"},
{InstType::VDIVSS, "VDIVSS"},
{InstType::VDPPD, "VDPPD"},
{InstType::VDPPS, "VDPPS"},
{InstType::VEXTRACTPS, "VEXTRACTPS"},
{InstType::HADDPD, "HADDPD"},
{InstType::HADDPS, "HADDPS"},
{InstType::HSUBPD, "HSUBPD"},
{InstType::HSUBPS, "HSUBPS"},
{InstType::VHADDPD, "VHADDPD"},
{InstType::VHADDPS, "VHADDPS"},
{InstType::VHSUBPD, "VHSUBPD"},
{InstType::VHSUBPS, "VHSUBPS"},
{InstType::MAXPD, "MAXPD"},
{InstType::MAXPS, "MAXPS"},
{InstType::MAXSD, "MAXSD"},
{InstType::MAXSS, "MAXSS"},
{InstType::MINPD, "MINPD"},
{InstType::MINPS, "MINPS"},
{InstType::MINSD, "MINSD"},
{InstType::MINSS, "MINSS"},
{InstType::VMAXPD, "VMAXPD"},
{InstType::VMAXPS, "VMAXPS"},
{InstType::VMAXSD, "VMAXSD"},
{InstType::VMAXSS, "VMAXSS"},
{InstType::VMINPD, "VMINPD"},
{InstType::VMINPS, "VMINPS"},
{InstType::VMINSD, "VMINSD"},
{InstType::VMINSS, "VMINSS"},
{InstType::MOVAPD, "MOVAPD"},
{InstType::MOVAPS, "MOVAPS"},
{InstType::MOVHLPS, "MOVHLPS"},
{InstType::MOVHPD, "MOVHPD"},
{InstType::MOVHPS, "MOVHPS"},
{InstType::MOVLHPS, "MOVLHPS"},
{InstType::MOVLPD, "MOVLPD"},
{InstType::MOVLPS, "MOVLPS"},
{InstType::MOVMSKPD, "MOVMSKPD"},
{InstType::MOVMSKPS, "MOVMSKPS"},
{InstType::MOVNTPD, "MOVNTPD"},
{InstType::MOVNTPS, "MOVNTPS"},
{InstType::MOVSD, "MOVSD"},
{InstType::MOVSHDUP, "MOVSHDUP"},
{InstType::MOVSLDUP, "MOVSLDUP"},
{InstType::MOVSS, "MOVSS"},
{InstType::MOVUPD, "MOVUPD"},
{InstType::MOVUPS, "MOVUPS"},
{InstType::MULPD, "MULPD"},
{InstType::MULPS, "MULPS"},
{InstType::MULSD, "MULSD"},
{InstType::MULSS, "MULSS"},
{InstType::VMOVAPD, "VMOVAPD"},
{InstType::VMOVAPS, "VMOVAPS"},
{InstType::VMOVHLPS, "VMOVHLPS"},
{InstType::VMOVHPD, "VMOVHPD"},
{InstType::VMOVHPS, "VMOVHPS"},
{InstType::VMOVLHPS, "VMOVLHPS"},
{InstType::VMOVLPD, "VMOVLPD"},
{InstType::VMOVLPS, "VMOVLPS"},
{InstType::VMOVMSKPD, "VMOVMSKPD"},
{InstType::VMOVMSKPS, "VMOVMSKPS"},
{InstType::VMOVNTPD, "VMOVNTPD"},
{InstType::VMOVNTPS, "VMOVNTPS"},
{InstType::VMOVSD, "VMOVSD"},
{InstType::VMOVSHDUP, "VMOVSHDUP"},
{InstType::VMOVSLDUP, "VMOVSLDUP"},
{InstType::VMOVSS, "VMOVSS"},
{InstType::VMOVUPD, "VMOVUPD"},
{InstType::VMOVUPS, "VMOVUPS"},
{InstType::VMULPD, "VMULPD"},
{InstType::VMULPS, "VMULPS"},
{InstType::VMULSD, "VMULSD"},
{InstType::VMULSS, "VMULSS"},
{InstType::ORPD, "ORPD"},
{InstType::ORPS, "ORPS"},
{InstType::RCPPS, "RCPPS"},
{InstType::RCPSS, "RCPSS"},
{InstType::ROUNDPD, "ROUNDPD"},
{InstType::ROUNDPS, "ROUNDPS"},
{InstType::ROUNDSD, "ROUNDSD"},
{InstType::ROUNDSS, "ROUNDSS"},
{InstType::RSQRTPS, "RSQRTPS"},
{InstType::RSQRTSS, "RSQRTSS"},
{InstType::SHUFPD, "SHUFPD"},
{InstType::SHUFPS, "SHUFPS"},
{InstType::SQRTPD, "SQRTPD"},
{InstType::SQRTPS, "SQRTPS"},
{InstType::SQRTSD, "SQRTSD"},
{InstType::SQRTSS, "SQRTSS"},
{InstType::VORPD, "VORPD"},
{InstType::VORPS, "VORPS"},
{InstType::VRCPPS, "VRCPPS"},
{InstType::VRCPSS, "VRCPSS"},
{InstType::VROUNDPD, "VROUNDPD"},
{InstType::VROUNDPS, "VROUNDPS"},
{InstType::VROUNDSD, "VROUNDSD"},
{InstType::VROUNDSS, "VROUNDSS"},
{InstType::VRSQRTPS, "VRSQRTPS"},
{InstType::VRSQRTSS, "VRSQRTSS"},
{InstType::VSHUFPD, "VSHUFPD"},
{InstType::VSHUFPS, "VSHUFPS"},
{InstType::VSQRTPD, "VSQRTPD"},
{InstType::VSQRTPS, "VSQRTPS"},
{InstType::VSQRTSD, "VSQRTSD"},
{InstType::VSQRTSS, "VSQRTSS"},
{InstType::SUBPD, "SUBPD"},
{InstType::SUBPS, "SUBPS"},
{InstType::SUBSD, "SUBSD"},
{InstType::SUBSS, "SUBSS"},
{InstType::VSUBPD, "VSUBPD"},
{InstType::VSUBPS, "VSUBPS"},
{InstType::VSUBSD, "VSUBSD"},
{InstType::VSUBSS, "VSUBSS"},
{InstType::UCOMISD, "UCOMISD"},
{InstType::UCOMISS, "UCOMISS"},
{InstType::VUCOMISD, "VUCOMISD"},
{InstType::VUCOMISS, "VUCOMISS"},
{InstType::UNPCKHPD, "UNPCKHPD"},
{InstType::UNPCKHPS, "UNPCKHPS"},
{InstType::UNPCKLPD, "UNPCKLPD"},
{InstType::UNPCKLPS, "UNPCKLPS"},
{InstType::VUNPCKHPD, "VUNPCKHPD"},
{InstType::VUNPCKHPS, "VUNPCKHPS"},
{InstType::VUNPCKLPD, "VUNPCKLPD"},
{InstType::VUNPCKLPS, "VUNPCKLPS"},
{InstType::VCVTPH2PS, "VCVTPH2PS"},
{InstType::VCVTPS2PH, "VCVTPS2PH"},
{InstType::VEXTRACTF128, "VEXTRACTF128"},
{InstType::VINSERTF128, "VINSERTF128"},
{InstType::VPERMILPD, "VPERMILPD"},
{InstType::VPERMILPS, "VPERMILPS"},
{InstType::VPERM2F128, "VPERM2F128"},
{InstType::XORPD, "XORPD"},
{InstType::XORPS, "XORPS"},
{InstType::VXORPD, "VXORPD"},
{InstType::VXORPS, "VXORPS"}
};
